package com.kj.tms.common.utils.calx.util;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

/**
 * @ProjectName: ledger
 * @Package: com.hongtu.tms.ledger.calx.factory
 * @ClassName: Table
 * @Description: []
 * @Author: [zhuyongjie]
 * @CreateDate: 2018/4/11 16:12
 * @UpdateUser: []
 * @UpdateDate: 2018/4/11 16:12
 * @UpdateRemark: []
 * @Version: 1.0
 * Copyright: 北京宏图天安 Copyright (c) 2018
 */
public class Table {
    private List<Map<Integer, Object>> table;

    public Table() {
        initTableData();

    }

    /**
     * 初始化值
     */
    private void initTableData() {
        table = new ArrayList<Map<Integer, Object>>();
        add1();
        add2();
        add3();
        add4();
        add5();
        add6();
        add7();
        add8();
        add9();
        add10();
        add11();
        add12();
        add13();
        add14();
        add15();
        add16();
        add17();
        add18();
        add19();
        add20();
        add21();
        add22();
        add23();
        add24();
        add25();
        add26();
        add27();
        add28();
        add29();
        add30();
        add31();
        add32();
        add33();
        add34();
        add35();
        add36();
        add37();
        add38();
        add39();
        add40();
        add41();
        add42();
        add43();
        add44();
        add45();
        add46();
        add47();
        add48();
        add49();
        add50();
        add51();
        add52();
        add53();
        add54();
        add55();
        add56();
        add57();
        add58();
        add59();
        add60();
        add61();
        add62();
        add63();
        add64();
        add65();
        add66();
        add67();
        add68();
        add69();
        add70();
        add71();
        add72();
        add73();
        add74();
        add75();
        add76();
        add77();
        add78();
        add79();
        add80();
        add81();
        add82();
        add83();
        add84();
        add85();
        add86();
        add87();
        add88();
        add89();
    }

    public List<Map<Integer, Object>> getTable() {
        return table;
    }

    public void setTable(List<Map<Integer, Object>> table) {
        this.table = table;
    }

    private void add1() {
        Map map = new HashMap();
        map.put(2, 18);
        map.put(3, 1);
        map.put(4, 2);
        map.put(6, 3);
        map.put(7, new int[]{1, 4});
        map.put(8, new int[]{1, 5});
        map.put(9, new int[]{1, 6});
        map.put(10, new int[]{1, 7});
        map.put(11, new int[]{1, 8});
        map.put(12, 9);
        map.put(13, new int[]{1, 10});
        map.put(16, new int[]{1, 14});
        map.put(17, new int[]{1, 11});
        map.put(19, new int[]{1, 12});
        map.put(25, new int[]{1, 13});
        map.put(29, new int[]{1, 15});
        map.put(30, new int[]{1, 16});
        map.put(31, 17);
        map.put(32, new int[]{1, 21});
        map.put(34, new int[]{1, 22});
        map.put(35, new int[]{1, 23});
        map.put(37, new int[]{1, 24});
        map.put(40, new int[]{1, 19});
        map.put(42, new int[]{1, 20});
        map.put(44, new int[]{1, 25});
        this.table.add(map);
    }

    private void add2() {
        Map map = new HashMap();
        map.put(1, new int[]{3});
        this.table.add(map);
    }

    private void add3() {
        Map map = new HashMap();
        map.put(5, new int[]{1, 26});
        map.put(14, new int[]{1, 27});
        map.put(15, new int[]{1, 28});
        map.put(16, new int[]{1, 29});
        map.put(22, new int[]{1, 30});
        map.put(23, new int[]{1, 31});
        map.put(24, new int[]{1, 32});
        map.put(25, new int[]{1, 33});
        map.put(26, new int[]{1, 34});
        map.put(27, new int[]{1, 35});
        map.put(28, new int[]{1, 36});
        this.table.add(map);
    }

    private void add4() {
        Map map = new HashMap();
        map.put(5, new int[]{2, 2});
        map.put(14, new int[]{2, 2});
        map.put(15, new int[]{2, 2});
        map.put(16, new int[]{2, 2});
        map.put(18, new int[]{2, 2});
        map.put(21, new int[]{2, 2});
        map.put(22, new int[]{2, 2});
        map.put(23, new int[]{2, 2});
        map.put(24, new int[]{2, 2});
        map.put(25, new int[]{2, 2});
        map.put(26, new int[]{2, 2});
        map.put(27, new int[]{2, 2});
        map.put(28, new int[]{2, 2});
        map.put(38, new int[]{2, 2});
        map.put(39, new int[]{2, 2});
        map.put(41, new int[]{1, 37});
        this.table.add(map);
    }

    private void add5() {
        Map map = new HashMap();
        map.put(5, new int[]{2, 3});
        map.put(14, new int[]{2, 3});
        map.put(15, new int[]{2, 3});
        map.put(16, new int[]{2, 3});
        map.put(18, new int[]{2, 3});
        map.put(21, new int[]{2, 3});
        map.put(22, new int[]{2, 3});
        map.put(23, new int[]{2, 3});
        map.put(24, new int[]{2, 3});
        map.put(25, new int[]{2, 3});
        map.put(26, new int[]{2, 3});
        map.put(27, new int[]{2, 3});
        map.put(28, new int[]{2, 3});
        map.put(38, new int[]{2, 3});
        map.put(39, new int[]{2, 3});
        this.table.add(map);
    }

    private void add6() {
        Map map = new HashMap();
        map.put(5, new int[]{2, 4});
        map.put(14, new int[]{2, 4});
        map.put(15, new int[]{2, 4});
        map.put(16, new int[]{2, 4});
        map.put(18, new int[]{2, 4});
        map.put(21, new int[]{2, 4});
        map.put(22, new int[]{2, 4});
        map.put(23, new int[]{2, 4});
        map.put(24, new int[]{2, 4});
        map.put(25, new int[]{2, 4});
        map.put(26, new int[]{2, 4});
        map.put(27, new int[]{2, 4});
        map.put(28, new int[]{2, 4});
        map.put(38, new int[]{2, 4});
        map.put(39, new int[]{2, 4});
        this.table.add(map);
    }

    private void add7() {
        Map map = new HashMap();
        map.put(5, new int[]{2, 5});
        map.put(14, new int[]{2, 5});
        map.put(15, new int[]{2, 5});
        map.put(16, new int[]{2, 5});
        map.put(18, new int[]{2, 5});
        map.put(21, new int[]{2, 5});
        map.put(22, new int[]{2, 5});
        map.put(23, new int[]{2, 5});
        map.put(24, new int[]{2, 5});
        map.put(25, new int[]{2, 5});
        map.put(26, new int[]{2, 5});
        map.put(27, new int[]{2, 5});
        map.put(28, new int[]{2, 5});
        map.put(38, new int[]{2, 5});
        map.put(39, new int[]{2, 5});
        this.table.add(map);
    }

    private void add8() {
        Map map = new HashMap();
        map.put(5, new int[]{2, 6});
        map.put(14, new int[]{2, 6});
        map.put(15, new int[]{2, 6});
        map.put(16, new int[]{2, 6});
        map.put(18, new int[]{2, 6});
        map.put(21, new int[]{2, 6});
        map.put(22, new int[]{2, 6});
        map.put(23, new int[]{2, 6});
        map.put(24, new int[]{2, 6});
        map.put(25, new int[]{2, 6});
        map.put(26, new int[]{2, 6});
        map.put(27, new int[]{2, 6});
        map.put(28, new int[]{2, 6});
        map.put(38, new int[]{2, 6});
        map.put(39, new int[]{2, 6});
        this.table.add(map);
    }

    private void add9() {
        Map map = new HashMap();
        map.put(5, new int[]{2, 7});
        map.put(14, new int[]{2, 7});
        map.put(15, new int[]{2, 7});
        map.put(16, new int[]{2, 7});
        map.put(18, new int[]{2, 7});
        map.put(21, new int[]{2, 7});
        map.put(22, new int[]{2, 7});
        map.put(23, new int[]{2, 7});
        map.put(24, new int[]{2, 7});
        map.put(25, new int[]{2, 7});
        map.put(26, new int[]{2, 7});
        map.put(27, new int[]{2, 7});
        map.put(28, new int[]{2, 7});
        map.put(38, new int[]{2, 7});
        map.put(39, new int[]{2, 7});
        this.table.add(map);
    }

    private void add10() {
        Map map = new HashMap();
        map.put(5, new int[]{2, 8});
        map.put(14, new int[]{2, 8});
        map.put(15, new int[]{2, 8});
        map.put(16, new int[]{2, 8});
        map.put(18, new int[]{2, 8});
        map.put(21, new int[]{2, 8});
        map.put(22, new int[]{2, 8});
        map.put(23, new int[]{2, 8});
        map.put(24, new int[]{2, 8});
        map.put(25, new int[]{2, 8});
        map.put(26, new int[]{2, 8});
        map.put(27, new int[]{2, 8});
        map.put(28, new int[]{2, 8});
        map.put(38, new int[]{2, 8});
        map.put(39, new int[]{2, 8});
        map.put(43, new int[]{1, 38});
        this.table.add(map);
    }

    private void add11() {
        Map map = new HashMap();
        map.put(5, new int[]{2, 9});
        map.put(14, new int[]{2, 9});
        map.put(15, new int[]{2, 9});
        map.put(16, new int[]{2, 9});
        map.put(18, new int[]{2, 9});
        map.put(21, new int[]{2, 9});
        map.put(22, new int[]{2, 9});
        map.put(23, new int[]{2, 9});
        map.put(24, new int[]{2, 9});
        map.put(25, new int[]{2, 9});
        map.put(26, new int[]{2, 9});
        map.put(27, new int[]{2, 9});
        map.put(28, new int[]{2, 9});
        map.put(38, new int[]{2, 9});
        map.put(39, new int[]{2, 9});
        this.table.add(map);
    }

    private void add12() {
        Map map = new HashMap();
        map.put(2, 18);
        map.put(4, 39);
        map.put(6, 3);
        map.put(7, new int[]{1, 4});
        map.put(8, new int[]{1, 5});
        map.put(9, new int[]{1, 6});
        map.put(10, new int[]{1, 7});
        map.put(11, new int[]{1, 8});
        map.put(12, 9);
        map.put(13, new int[]{1, 10});
        map.put(16, new int[]{1, 14});
        map.put(17, new int[]{1, 11});
        map.put(19, new int[]{1, 12});
        map.put(25, new int[]{1, 13});
        map.put(29, new int[]{1, 15});
        map.put(30, new int[]{1, 16});
        map.put(31, 17);
        map.put(32, new int[]{1, 21});
        map.put(34, new int[]{1, 22});
        map.put(35, new int[]{1, 23});
        map.put(37, new int[]{1, 24});
        map.put(40, new int[]{1, 19});
        map.put(42, new int[]{1, 20});
        map.put(44, new int[]{1, 25});
        this.table.add(map);
    }

    private void add13() {
        Map map = new HashMap();
        map.put(2, 18);
        map.put(4, 41);
        map.put(6, 3);
        map.put(7, new int[]{1, 4});
        map.put(8, new int[]{1, 5});
        map.put(9, new int[]{1, 6});
        map.put(10, new int[]{1, 7});
        map.put(11, new int[]{1, 8});
        map.put(12, 9);
        map.put(13, new int[]{1, 10});
        map.put(16, new int[]{1, 14});
        map.put(17, new int[]{1, 11});
        map.put(19, new int[]{1, 12});
        map.put(20, 40);
        map.put(25, new int[]{1, 13});
        map.put(29, new int[]{1, 15});
        map.put(30, new int[]{1, 16});
        map.put(31, 17);
        map.put(32, new int[]{1, 21});
        map.put(34, new int[]{1, 22});
        map.put(35, new int[]{1, 23});
        map.put(37, new int[]{1, 24});
        map.put(40, new int[]{1, 19});
        map.put(42, new int[]{1, 20});
        map.put(44, new int[]{1, 25});
        this.table.add(map);
    }

    private void add14() {
        Map map = new HashMap();
        map.put(2, 18);
        map.put(4, 42);
        map.put(6, 3);
        map.put(7, new int[]{1, 4});
        map.put(8, new int[]{1, 5});
        map.put(9, new int[]{1, 6});
        map.put(10, new int[]{1, 7});
        map.put(11, new int[]{1, 8});
        map.put(12, 9);
        map.put(13, new int[]{1, 10});
        map.put(16, new int[]{1, 14});
        map.put(17, new int[]{1, 11});
        map.put(19, new int[]{1, 12});
        map.put(25, new int[]{1, 13});
        map.put(29, new int[]{1, 15});
        map.put(30, new int[]{1, 16});
        map.put(31, 17);
        map.put(32, new int[]{1, 21});
        map.put(34, new int[]{1, 22});
        map.put(35, new int[]{1, 23});
        map.put(37, new int[]{1, 24});
        map.put(40, new int[]{1, 19});
        map.put(42, new int[]{1, 20});
        map.put(44, new int[]{1, 25});
        this.table.add(map);
    }

    private void add15() {
        Map map = new HashMap();
        map.put(2, 18);
        map.put(4, 43);
        map.put(6, 3);
        map.put(7, new int[]{1, 4});
        map.put(8, new int[]{1, 5});
        map.put(9, new int[]{1, 6});
        map.put(10, new int[]{1, 7});
        map.put(11, new int[]{1, 8});
        map.put(12, 9);
        map.put(13, new int[]{1, 10});
        map.put(16, new int[]{1, 14});
        map.put(17, new int[]{1, 11});
        map.put(19, new int[]{1, 12});
        map.put(25, new int[]{1, 13});
        map.put(29, new int[]{1, 15});
        map.put(30, new int[]{1, 16});
        map.put(31, 17);
        map.put(32, new int[]{1, 21});
        map.put(34, new int[]{1, 22});
        map.put(35, new int[]{1, 23});
        map.put(37, new int[]{1, 24});
        map.put(40, new int[]{1, 19});
        map.put(42, new int[]{1, 20});
        map.put(44, new int[]{1, 25});
        this.table.add(map);
    }

    private void add16() {
        Map map = new HashMap();
        map.put(5, new int[]{2, 27});
        map.put(14, new int[]{2, 27});
        map.put(15, new int[]{2, 27});
        map.put(16, new int[]{2, 27});
        map.put(18, new int[]{2, 27});
        map.put(21, new int[]{2, 27});
        map.put(22, new int[]{2, 27});
        map.put(23, new int[]{2, 27});
        map.put(24, new int[]{2, 27});
        map.put(25, new int[]{2, 27});
        map.put(26, new int[]{2, 27});
        map.put(27, new int[]{2, 27});
        map.put(28, new int[]{2, 27});
        map.put(38, new int[]{2, 27});
        map.put(39, new int[]{2, 27});
        this.table.add(map);
    }

    private void add17() {
        Map map = new HashMap();
        map.put(17, new int[]{1, 44});
        this.table.add(map);
    }

    private void add18() {
        Map map = new HashMap();
        map.put(5, new int[]{2, 30});
        map.put(14, new int[]{2, 30});
        map.put(15, new int[]{2, 30});
        map.put(16, new int[]{2, 30});
        map.put(18, new int[]{2, 30});
        map.put(21, new int[]{2, 30});
        map.put(22, new int[]{2, 30});
        map.put(23, new int[]{2, 30});
        map.put(24, new int[]{2, 30});
        map.put(25, new int[]{2, 30});
        map.put(26, new int[]{2, 30});
        map.put(27, new int[]{2, 30});
        map.put(28, new int[]{2, 30});
        map.put(38, new int[]{2, 30});
        map.put(39, new int[]{2, 30});
        this.table.add(map);
    }

    private void add19() {
        Map map = new HashMap();
        map.put(2, 45);
        map.put(5, new int[]{2, 31});
        map.put(14, new int[]{2, 31});
        map.put(15, new int[]{2, 31});
        map.put(16, new int[]{2, 31});
        map.put(18, new int[]{2, 31});
        map.put(21, new int[]{2, 31});
        map.put(22, new int[]{2, 31});
        map.put(23, new int[]{2, 31});
        map.put(24, new int[]{2, 31});
        map.put(25, new int[]{2, 31});
        map.put(26, new int[]{2, 31});
        map.put(27, new int[]{2, 31});
        map.put(28, new int[]{2, 31});
        map.put(38, new int[]{2, 31});
        map.put(39, new int[]{2, 31});
        map.put(40, new int[]{1, 46});
        map.put(44, new int[]{1, 25});
        this.table.add(map);
    }

    private void add20() {
        Map map = new HashMap();
        map.put(5, new int[]{2, 44});
        map.put(14, new int[]{2, 44});
        map.put(15, new int[]{2, 44});
        map.put(16, new int[]{2, 44});
        map.put(18, new int[]{2, 44});
        map.put(21, new int[]{2, 44});
        map.put(22, new int[]{2, 44});
        map.put(23, new int[]{2, 44});
        map.put(24, new int[]{2, 44});
        map.put(25, new int[]{2, 44});
        map.put(26, new int[]{2, 44});
        map.put(27, new int[]{2, 44});
        map.put(28, new int[]{2, 44});
        map.put(38, new int[]{2, 44});
        map.put(39, new int[]{2, 44});
        map.put(41, new int[]{2, 44});
        map.put(44, new int[]{1, 47});
        this.table.add(map);
    }

    private void add21() {
        Map map = new HashMap();
        map.put(5, new int[]{2, 46});
        map.put(14, new int[]{2, 46});
        map.put(15, new int[]{2, 46});
        map.put(16, new int[]{2, 46});
        map.put(18, new int[]{2, 46});
        map.put(21, new int[]{2, 46});
        map.put(22, new int[]{2, 46});
        map.put(23, new int[]{2, 46});
        map.put(24, new int[]{2, 46});
        map.put(25, new int[]{2, 46});
        map.put(26, new int[]{2, 46});
        map.put(27, new int[]{2, 46});
        map.put(28, new int[]{2, 46});
        map.put(38, new int[]{2, 46});
        map.put(39, new int[]{2, 46});
        map.put(41, new int[]{1, 48});
        map.put(43, new int[]{2, 46});
        this.table.add(map);
    }

    private void add22() {
        Map map = new HashMap();
        map.put(5, new int[]{2, 33});
        map.put(14, new int[]{2, 33});
        map.put(15, new int[]{2, 33});
        map.put(16, new int[]{2, 33});
        map.put(18, new int[]{2, 33});
        map.put(21, new int[]{2, 33});
        map.put(22, new int[]{2, 33});
        map.put(23, new int[]{2, 33});
        map.put(24, new int[]{2, 33});
        map.put(25, new int[]{2, 33});
        map.put(26, new int[]{2, 33});
        map.put(27, new int[]{2, 33});
        map.put(28, new int[]{2, 33});
        map.put(33, new int[]{1, 49});
        map.put(38, new int[]{2, 33});
        map.put(39, new int[]{2, 33});
        this.table.add(map);
    }

    private void add23() {
        Map map = new HashMap();
        map.put(5, new int[]{2, 35});
        map.put(14, new int[]{2, 35});
        map.put(15, new int[]{2, 35});
        map.put(16, new int[]{2, 35});
        map.put(18, new int[]{2, 35});
        map.put(21, new int[]{2, 35});
        map.put(22, new int[]{2, 35});
        map.put(23, new int[]{2, 35});
        map.put(24, new int[]{2, 35});
        map.put(25, new int[]{2, 35});
        map.put(26, new int[]{2, 35});
        map.put(27, new int[]{2, 35});
        map.put(28, new int[]{2, 35});
        map.put(33, new int[]{1, 50});
        map.put(38, new int[]{2, 35});
        map.put(39, new int[]{2, 35});
        this.table.add(map);
    }

    private void add24() {
        Map map = new HashMap();
        map.put(36, new int[]{1, 51});
        this.table.add(map);
    }

    private void add25() {
        Map map = new HashMap();
        map.put(5, new int[]{2, 39});
        map.put(14, new int[]{2, 39});
        map.put(15, new int[]{2, 39});
        map.put(16, new int[]{2, 39});
        map.put(18, new int[]{2, 39});
        map.put(21, new int[]{2, 39});
        map.put(22, new int[]{2, 39});
        map.put(23, new int[]{2, 39});
        map.put(24, new int[]{2, 39});
        map.put(25, new int[]{2, 39});
        map.put(26, new int[]{2, 39});
        map.put(27, new int[]{2, 39});
        map.put(28, new int[]{2, 39});
        map.put(38, new int[]{2, 39});
        map.put(39, new int[]{2, 39});
        this.table.add(map);
    }

    private void add26() {
        Map map = new HashMap();
        map.put(40, new int[]{1, 52});
        this.table.add(map);
    }

    private void add27() {
        Map map = new HashMap();
        map.put(1, new int[]{2, 1});
        this.table.add(map);
    }

    private void add28() {
        Map map = new HashMap();
        map.put(2, 18);
        map.put(4, 53);
        map.put(6, 3);
        map.put(7, new int[]{1, 4});
        map.put(8, new int[]{1, 5});
        map.put(9, new int[]{1, 6});
        map.put(10, new int[]{1, 7});
        map.put(11, new int[]{1, 8});
        map.put(12, 9);
        map.put(13, new int[]{1, 10});
        map.put(16, new int[]{1, 14});
        map.put(17, new int[]{1, 11});
        map.put(19, new int[]{1, 12});
        map.put(25, new int[]{1, 13});
        map.put(29, new int[]{1, 15});
        map.put(30, new int[]{1, 16});
        map.put(31, 17);
        map.put(32, new int[]{1, 21});
        map.put(34, new int[]{1, 22});
        map.put(35, new int[]{1, 23});
        map.put(37, new int[]{1, 24});
        map.put(40, new int[]{1, 19});
        map.put(42, new int[]{1, 20});
        map.put(44, new int[]{1, 25});
        this.table.add(map);
    }

    private void add29() {
        Map map = new HashMap();
        map.put(2, 18);
        map.put(4, 54);
        map.put(6, 3);
        map.put(7, new int[]{1, 4});
        map.put(8, new int[]{1, 5});
        map.put(9, new int[]{1, 6});
        map.put(10, new int[]{1, 7});
        map.put(11, new int[]{1, 8});
        map.put(12, 9);
        map.put(13, new int[]{1, 10});
        map.put(16, new int[]{1, 14});
        map.put(17, new int[]{1, 11});
        map.put(19, new int[]{1, 12});
        map.put(25, new int[]{1, 13});
        map.put(29, new int[]{1, 15});
        map.put(30, new int[]{1, 16});
        map.put(31, 17);
        map.put(32, new int[]{1, 21});
        map.put(34, new int[]{1, 22});
        map.put(35, new int[]{1, 23});
        map.put(37, new int[]{1, 24});
        map.put(40, new int[]{1, 19});
        map.put(42, new int[]{1, 20});
        map.put(44, new int[]{1, 25});
        this.table.add(map);
    }

    private void add30() {
        Map map = new HashMap();
        map.put(2, 18);
        map.put(4, 55);
        map.put(6, 3);
        map.put(7, new int[]{1, 4});
        map.put(8, new int[]{1, 5});
        map.put(9, new int[]{1, 6});
        map.put(10, new int[]{1, 7});
        map.put(11, new int[]{1, 8});
        map.put(12, 9);
        map.put(13, new int[]{1, 10});
        map.put(16, new int[]{1, 14});
        map.put(17, new int[]{1, 11});
        map.put(19, new int[]{1, 12});
        map.put(25, new int[]{1, 13});
        map.put(29, new int[]{1, 15});
        map.put(30, new int[]{1, 16});
        map.put(31, 17);
        map.put(32, new int[]{1, 21});
        map.put(34, new int[]{1, 22});
        map.put(35, new int[]{1, 23});
        map.put(37, new int[]{1, 24});
        map.put(40, new int[]{1, 19});
        map.put(42, new int[]{1, 20});
        map.put(44, new int[]{1, 25});
        this.table.add(map);
    }

    private void add31() {
        Map map = new HashMap();
        map.put(2, 18);
        map.put(4, 58);
        map.put(6, 3);
        map.put(7, new int[]{1, 4});
        map.put(8, new int[]{1, 5});
        map.put(9, new int[]{1, 6});
        map.put(10, new int[]{1, 7});
        map.put(11, new int[]{1, 8});
        map.put(12, 9);
        map.put(13, new int[]{1, 10});
        map.put(15, new int[]{1, 56});
        map.put(16, new int[]{1, 14});
        map.put(17, new int[]{1, 11});
        map.put(19, new int[]{1, 12});
        map.put(23, new int[]{1, 57});
        map.put(25, new int[]{1, 13});
        map.put(29, new int[]{1, 15});
        map.put(30, new int[]{1, 16});
        map.put(31, 17);
        map.put(32, new int[]{1, 21});
        map.put(34, new int[]{1, 22});
        map.put(35, new int[]{1, 23});
        map.put(37, new int[]{1, 24});
        map.put(40, new int[]{1, 19});
        map.put(42, new int[]{1, 20});
        map.put(44, new int[]{1, 25});
        this.table.add(map);
    }

    private void add32() {
        Map map = new HashMap();
        map.put(2, 18);
        map.put(4, 60);
        map.put(6, 3);
        map.put(7, new int[]{1, 4});
        map.put(8, new int[]{1, 5});
        map.put(9, new int[]{1, 6});
        map.put(10, new int[]{1, 7});
        map.put(11, new int[]{1, 8});
        map.put(12, 9);
        map.put(13, new int[]{1, 10});
        map.put(15, new int[]{1, 59});
        map.put(16, new int[]{1, 14});
        map.put(17, new int[]{1, 11});
        map.put(19, new int[]{1, 12});
        map.put(25, new int[]{1, 13});
        map.put(29, new int[]{1, 15});
        map.put(30, new int[]{1, 16});
        map.put(31, 17);
        map.put(32, new int[]{1, 21});
        map.put(34, new int[]{1, 22});
        map.put(35, new int[]{1, 23});
        map.put(37, new int[]{1, 24});
        map.put(40, new int[]{1, 19});
        map.put(42, new int[]{1, 20});
        map.put(44, new int[]{1, 25});
        this.table.add(map);
    }

    private void add33() {
        Map map = new HashMap();
        map.put(2, 18);
        map.put(4, 61);
        map.put(6, 3);
        map.put(7, new int[]{1, 4});
        map.put(8, new int[]{1, 5});
        map.put(9, new int[]{1, 6});
        map.put(10, new int[]{1, 7});
        map.put(11, new int[]{1, 8});
        map.put(12, 9);
        map.put(13, new int[]{1, 10});
        map.put(16, new int[]{1, 14});
        map.put(17, new int[]{1, 11});
        map.put(19, new int[]{1, 12});
        map.put(25, new int[]{1, 13});
        map.put(29, new int[]{1, 15});
        map.put(30, new int[]{1, 16});
        map.put(31, 17);
        map.put(32, new int[]{1, 21});
        map.put(34, new int[]{1, 22});
        map.put(35, new int[]{1, 23});
        map.put(37, new int[]{1, 24});
        map.put(40, new int[]{1, 19});
        map.put(42, new int[]{1, 20});
        map.put(44, new int[]{1, 25});
        this.table.add(map);
    }

    private void add34() {
        Map map = new HashMap();
        map.put(2, 18);
        map.put(4, 62);
        map.put(6, 3);
        map.put(7, new int[]{1, 4});
        map.put(8, new int[]{1, 5});
        map.put(9, new int[]{1, 6});
        map.put(10, new int[]{1, 7});
        map.put(11, new int[]{1, 8});
        map.put(12, 9);
        map.put(13, new int[]{1, 10});
        map.put(16, new int[]{1, 14});
        map.put(17, new int[]{1, 11});
        map.put(19, new int[]{1, 12});
        map.put(25, new int[]{1, 13});
        map.put(29, new int[]{1, 15});
        map.put(30, new int[]{1, 16});
        map.put(31, 17);
        map.put(32, new int[]{1, 21});
        map.put(34, new int[]{1, 22});
        map.put(35, new int[]{1, 23});
        map.put(37, new int[]{1, 24});
        map.put(40, new int[]{1, 19});
        map.put(42, new int[]{1, 20});
        map.put(44, new int[]{1, 25});
        this.table.add(map);
    }

    private void add35() {
        Map map = new HashMap();
        map.put(2, 18);
        map.put(4, 63);
        map.put(6, 3);
        map.put(7, new int[]{1, 4});
        map.put(8, new int[]{1, 5});
        map.put(9, new int[]{1, 6});
        map.put(10, new int[]{1, 7});
        map.put(11, new int[]{1, 8});
        map.put(12, 9);
        map.put(13, new int[]{1, 10});
        map.put(16, new int[]{1, 14});
        map.put(17, new int[]{1, 11});
        map.put(19, new int[]{1, 12});
        map.put(25, new int[]{1, 13});
        map.put(29, new int[]{1, 15});
        map.put(30, new int[]{1, 16});
        map.put(31, 17);
        map.put(32, new int[]{1, 21});
        map.put(34, new int[]{1, 22});
        map.put(35, new int[]{1, 23});
        map.put(37, new int[]{1, 24});
        map.put(40, new int[]{1, 19});
        map.put(42, new int[]{1, 20});
        map.put(44, new int[]{1, 25});
        this.table.add(map);
    }

    private void add36() {
        Map map = new HashMap();
        map.put(2, 18);
        map.put(4, 64);
        map.put(6, 3);
        map.put(7, new int[]{1, 4});
        map.put(8, new int[]{1, 5});
        map.put(9, new int[]{1, 6});
        map.put(10, new int[]{1, 7});
        map.put(11, new int[]{1, 8});
        map.put(12, 9);
        map.put(13, new int[]{1, 10});
        map.put(16, new int[]{1, 14});
        map.put(17, new int[]{1, 11});
        map.put(19, new int[]{1, 12});
        map.put(25, new int[]{1, 13});
        map.put(29, new int[]{1, 15});
        map.put(30, new int[]{1, 16});
        map.put(31, 17);
        map.put(32, new int[]{1, 21});
        map.put(34, new int[]{1, 22});
        map.put(35, new int[]{1, 23});
        map.put(37, new int[]{1, 24});
        map.put(40, new int[]{1, 19});
        map.put(42, new int[]{1, 20});
        map.put(44, new int[]{1, 25});
        this.table.add(map);
    }

    private void add37() {
        Map map = new HashMap();
        map.put(2, 18);
        map.put(4, 65);
        map.put(6, 3);
        map.put(7, new int[]{1, 4});
        map.put(8, new int[]{1, 5});
        map.put(9, new int[]{1, 6});
        map.put(10, new int[]{1, 7});
        map.put(11, new int[]{1, 8});
        map.put(12, 9);
        map.put(13, new int[]{1, 10});
        map.put(16, new int[]{1, 14});
        map.put(17, new int[]{1, 11});
        map.put(19, new int[]{1, 12});
        map.put(25, new int[]{1, 13});
        map.put(29, new int[]{1, 15});
        map.put(30, new int[]{1, 16});
        map.put(31, 17);
        map.put(32, new int[]{1, 21});
        map.put(34, new int[]{1, 22});
        map.put(35, new int[]{1, 23});
        map.put(37, new int[]{1, 24});
        map.put(40, new int[]{1, 19});
        map.put(42, new int[]{1, 20});
        map.put(44, new int[]{1, 25});
        this.table.add(map);
    }

    private void add38() {
        Map map = new HashMap();
        map.put(40, new int[]{1, 66});
        this.table.add(map);
    }

    private void add39() {
        Map map = new HashMap();
        map.put(5, new int[]{2, 48});
        map.put(14, new int[]{2, 48});
        map.put(15, new int[]{2, 48});
        map.put(16, new int[]{2, 48});
        map.put(18, new int[]{2, 48});
        map.put(21, new int[]{2, 48});
        map.put(22, new int[]{2, 48});
        map.put(23, new int[]{2, 48});
        map.put(24, new int[]{2, 48});
        map.put(25, new int[]{2, 48});
        map.put(26, new int[]{2, 48});
        map.put(27, new int[]{2, 48});
        map.put(28, new int[]{2, 48});
        map.put(38, new int[]{2, 48});
        map.put(39, new int[]{2, 48});
        map.put(43, new int[]{2, 48});
        this.table.add(map);
    }

    private void add40() {
        Map map = new HashMap();
        map.put(14, new int[]{1, 27});
        map.put(15, new int[]{1, 28});
        map.put(16, new int[]{1, 29});
        map.put(18, new int[]{1, 67});
        map.put(22, new int[]{1, 30});
        map.put(23, new int[]{1, 31});
        map.put(24, new int[]{1, 32});
        map.put(25, new int[]{1, 33});
        map.put(26, new int[]{1, 34});
        map.put(27, new int[]{1, 35});
        map.put(28, new int[]{1, 36});
        this.table.add(map);
    }

    private void add41() {
        Map map = new HashMap();
        map.put(21, new int[]{1, 68});
        map.put(38, new int[]{1, 69});
        map.put(39, new int[]{1, 70});
        this.table.add(map);
    }

    private void add42() {
        Map map = new HashMap();
        map.put(14, new int[]{1, 27});
        map.put(15, new int[]{1, 28});
        map.put(16, new int[]{1, 29});
        map.put(18, new int[]{2, 41});
        map.put(21, new int[]{2, 41});
        map.put(22, new int[]{1, 30});
        map.put(23, new int[]{1, 31});
        map.put(24, new int[]{1, 32});
        map.put(25, new int[]{1, 33});
        map.put(26, new int[]{1, 34});
        map.put(27, new int[]{1, 35});
        map.put(28, new int[]{1, 36});
        map.put(38, new int[]{2, 41});
        map.put(39, new int[]{2, 41});
        this.table.add(map);
    }

    private void add43() {
        Map map = new HashMap();
        map.put(5, new int[]{2, 25});
        map.put(14, new int[]{2, 25});
        map.put(15, new int[]{2, 25});
        map.put(16, new int[]{2, 25});
        map.put(18, new int[]{2, 25});
        map.put(21, new int[]{2, 25});
        map.put(22, new int[]{2, 25});
        map.put(23, new int[]{2, 25});
        map.put(24, new int[]{2, 25});
        map.put(25, new int[]{2, 25});
        map.put(26, new int[]{1, 34});
        map.put(27, new int[]{1, 35});
        map.put(28, new int[]{1, 36});
        map.put(38, new int[]{2, 25});
        map.put(39, new int[]{2, 25});
        this.table.add(map);
    }

    private void add44() {
        Map map = new HashMap();
        map.put(5, new int[]{2, 26});
        map.put(14, new int[]{2, 26});
        map.put(15, new int[]{2, 26});
        map.put(16, new int[]{2, 26});
        map.put(18, new int[]{2, 26});
        map.put(21, new int[]{2, 26});
        map.put(22, new int[]{2, 26});
        map.put(23, new int[]{2, 26});
        map.put(24, new int[]{2, 26});
        map.put(25, new int[]{2, 26});
        map.put(26, new int[]{1, 34});
        map.put(27, new int[]{1, 35});
        map.put(28, new int[]{1, 36});
        map.put(38, new int[]{2, 26});
        map.put(39, new int[]{2, 26});
        this.table.add(map);
    }

    private void add45() {
        Map map = new HashMap();
        map.put(2, 18);
        map.put(4, 41);
        map.put(6, 3);
        map.put(7, new int[]{1, 4});
        map.put(8, new int[]{1, 5});
        map.put(9, new int[]{1, 6});
        map.put(10, new int[]{1, 7});
        map.put(11, new int[]{1, 8});
        map.put(12, 9);
        map.put(13, new int[]{1, 10});
        map.put(16, new int[]{1, 14});
        map.put(17, new int[]{1, 11});
        map.put(18, new int[]{1, 71});
        map.put(19, new int[]{1, 12});
        map.put(20, 72);
        map.put(25, new int[]{1, 13});
        map.put(29, new int[]{1, 15});
        map.put(30, new int[]{1, 16});
        map.put(31, 17);
        map.put(32, new int[]{1, 21});
        map.put(34, new int[]{1, 22});
        map.put(35, new int[]{1, 23});
        map.put(37, new int[]{1, 24});
        map.put(40, new int[]{1, 19});
        map.put(42, new int[]{1, 20});
        map.put(44, new int[]{1, 25});
        this.table.add(map);
    }

    private void add46() {
        Map map = new HashMap();
        map.put(5, new int[]{2, 32});
        map.put(14, new int[]{2, 32});
        map.put(15, new int[]{2, 32});
        map.put(16, new int[]{2, 32});
        map.put(18, new int[]{2, 32});
        map.put(21, new int[]{2, 32});
        map.put(22, new int[]{2, 32});
        map.put(23, new int[]{2, 32});
        map.put(24, new int[]{2, 32});
        map.put(25, new int[]{2, 32});
        map.put(26, new int[]{2, 32});
        map.put(27, new int[]{2, 32});
        map.put(28, new int[]{2, 32});
        map.put(38, new int[]{2, 32});
        map.put(39, new int[]{2, 32});
        this.table.add(map);
    }

    private void add47() {
        Map map = new HashMap();
        map.put(44, new int[]{1, 47});
        this.table.add(map);
    }

    private void add48() {
        Map map = new HashMap();
        map.put(40, new int[]{1, 73});
        this.table.add(map);
    }

    private void add49() {
        Map map = new HashMap();
        map.put(42, new int[]{1, 74});
        this.table.add(map);
    }

    private void add50() {
        Map map = new HashMap();
        map.put(32, new int[]{1, 75});
        this.table.add(map);
    }

    private void add51() {
        Map map = new HashMap();
        map.put(34, new int[]{1, 76});
        this.table.add(map);
    }

    private void add52() {
        Map map = new HashMap();
        map.put(34, new int[]{1, 77});
        map.put(37, new int[]{1, 78});
        this.table.add(map);
    }

    private void add53() {
        Map map = new HashMap();
        map.put(36, new int[]{1, 79});
        this.table.add(map);
    }

    private void add54() {
        Map map = new HashMap();
        map.put(5, new int[]{2, 10});
        map.put(14, new int[]{2, 10});
        map.put(15, new int[]{2, 10});
        map.put(16, new int[]{1, 29});
        map.put(18, new int[]{2, 10});
        map.put(21, new int[]{2, 10});
        map.put(22, new int[]{1, 30});
        map.put(23, new int[]{1, 31});
        map.put(24, new int[]{1, 32});
        map.put(25, new int[]{1, 33});
        map.put(26, new int[]{1, 34});
        map.put(27, new int[]{1, 35});
        map.put(28, new int[]{1, 36});
        map.put(38, new int[]{2, 10});
        map.put(39, new int[]{2, 10});
        this.table.add(map);
    }

    private void add55() {
        Map map = new HashMap();
        map.put(5, new int[]{2, 11});
        map.put(14, new int[]{2, 11});
        map.put(15, new int[]{2, 11});
        map.put(16, new int[]{1, 29});
        map.put(18, new int[]{2, 11});
        map.put(21, new int[]{2, 11});
        map.put(22, new int[]{1, 30});
        map.put(23, new int[]{1, 31});
        map.put(24, new int[]{1, 32});
        map.put(25, new int[]{1, 33});
        map.put(26, new int[]{1, 34});
        map.put(27, new int[]{1, 35});
        map.put(28, new int[]{1, 36});
        map.put(38, new int[]{2, 11});
        map.put(39, new int[]{2, 11});
        this.table.add(map);
    }

    private void add56() {
        Map map = new HashMap();
        map.put(5, new int[]{2, 12});
        map.put(14, new int[]{2, 12});
        map.put(15, new int[]{2, 12});
        map.put(16, new int[]{2, 12});
        map.put(18, new int[]{2, 12});
        map.put(21, new int[]{2, 12});
        map.put(22, new int[]{2, 12});
        map.put(23, new int[]{2, 12});
        map.put(24, new int[]{2, 12});
        map.put(25, new int[]{2, 12});
        map.put(26, new int[]{1, 34});
        map.put(27, new int[]{1, 35});
        map.put(28, new int[]{1, 36});
        map.put(38, new int[]{2, 12});
        map.put(39, new int[]{2, 12});
        this.table.add(map);
    }

    private void add57() {
        Map map = new HashMap();
        map.put(2, 18);
        map.put(4, 80);
        map.put(6, 3);
        map.put(7, new int[]{1, 4});
        map.put(8, new int[]{1, 5});
        map.put(9, new int[]{1, 6});
        map.put(10, new int[]{1, 7});
        map.put(11, new int[]{1, 8});
        map.put(12, 9);
        map.put(13, new int[]{1, 10});
        map.put(16, new int[]{1, 14});
        map.put(17, new int[]{1, 11});
        map.put(19, new int[]{1, 12});
        map.put(25, new int[]{1, 13});
        map.put(29, new int[]{1, 15});
        map.put(30, new int[]{1, 16});
        map.put(31, 17);
        map.put(32, new int[]{1, 21});
        map.put(34, new int[]{1, 22});
        map.put(35, new int[]{1, 23});
        map.put(37, new int[]{1, 24});
        map.put(40, new int[]{1, 19});
        map.put(42, new int[]{1, 20});
        map.put(44, new int[]{1, 25});
        this.table.add(map);
    }

    private void add58() {
        Map map = new HashMap();
        map.put(2, 18);
        map.put(4, 81);
        map.put(6, 3);
        map.put(7, new int[]{1, 4});
        map.put(8, new int[]{1, 5});
        map.put(9, new int[]{1, 6});
        map.put(10, new int[]{1, 7});
        map.put(11, new int[]{1, 8});
        map.put(12, 9);
        map.put(13, new int[]{1, 10});
        map.put(16, new int[]{1, 14});
        map.put(17, new int[]{1, 11});
        map.put(19, new int[]{1, 12});
        map.put(25, new int[]{1, 13});
        map.put(29, new int[]{1, 15});
        map.put(30, new int[]{1, 16});
        map.put(31, 17);
        map.put(32, new int[]{1, 21});
        map.put(34, new int[]{1, 22});
        map.put(35, new int[]{1, 23});
        map.put(37, new int[]{1, 24});
        map.put(40, new int[]{1, 19});
        map.put(42, new int[]{1, 20});
        map.put(44, new int[]{1, 25});
        this.table.add(map);
    }

    private void add59() {
        Map map = new HashMap();
        map.put(5, new int[]{2, 20});
        map.put(14, new int[]{2, 20});
        map.put(15, new int[]{2, 20});
        map.put(16, new int[]{1, 29});
        map.put(18, new int[]{2, 20});
        map.put(21, new int[]{2, 20});
        map.put(22, new int[]{2, 20});
        map.put(23, new int[]{2, 20});
        map.put(24, new int[]{2, 20});
        map.put(25, new int[]{1, 33});
        map.put(26, new int[]{1, 34});
        map.put(27, new int[]{1, 35});
        map.put(28, new int[]{1, 36});
        map.put(38, new int[]{2, 20});
        map.put(39, new int[]{2, 20});
        this.table.add(map);
    }

    private void add60() {
        Map map = new HashMap();
        map.put(2, 18);
        map.put(4, 82);
        map.put(6, 3);
        map.put(7, new int[]{1, 4});
        map.put(8, new int[]{1, 5});
        map.put(9, new int[]{1, 6});
        map.put(10, new int[]{1, 7});
        map.put(11, new int[]{1, 8});
        map.put(12, 9);
        map.put(13, new int[]{1, 10});
        map.put(16, new int[]{1, 14});
        map.put(17, new int[]{1, 11});
        map.put(19, new int[]{1, 12});
        map.put(25, new int[]{1, 13});
        map.put(29, new int[]{1, 15});
        map.put(30, new int[]{1, 16});
        map.put(31, 17);
        map.put(32, new int[]{1, 21});
        map.put(34, new int[]{1, 22});
        map.put(35, new int[]{1, 23});
        map.put(37, new int[]{1, 24});
        map.put(40, new int[]{1, 19});
        map.put(42, new int[]{1, 20});
        map.put(44, new int[]{1, 25});
        this.table.add(map);
    }

    private void add61() {
        Map map = new HashMap();
        map.put(5, new int[]{2, 19});
        map.put(14, new int[]{2, 19});
        map.put(15, new int[]{2, 19});
        map.put(16, new int[]{1, 29});
        map.put(18, new int[]{2, 19});
        map.put(21, new int[]{2, 19});
        map.put(22, new int[]{2, 19});
        map.put(23, new int[]{2, 19});
        map.put(24, new int[]{2, 19});
        map.put(25, new int[]{1, 33});
        map.put(26, new int[]{1, 34});
        map.put(27, new int[]{1, 35});
        map.put(28, new int[]{1, 36});
        map.put(38, new int[]{2, 19});
        map.put(39, new int[]{2, 19});
        this.table.add(map);
    }

    private void add62() {
        Map map = new HashMap();
        map.put(5, new int[]{2, 18});
        map.put(14, new int[]{2, 18});
        map.put(15, new int[]{2, 18});
        map.put(16, new int[]{1, 29});
        map.put(18, new int[]{2, 18});
        map.put(21, new int[]{2, 18});
        map.put(22, new int[]{1, 30});
        map.put(23, new int[]{1, 31});
        map.put(24, new int[]{2, 18});
        map.put(25, new int[]{1, 33});
        map.put(26, new int[]{1, 34});
        map.put(27, new int[]{1, 35});
        map.put(28, new int[]{1, 36});
        map.put(38, new int[]{2, 18});
        map.put(39, new int[]{2, 18});
        this.table.add(map);
    }

    private void add63() {
        Map map = new HashMap();
        map.put(5, new int[]{2, 21});
        map.put(14, new int[]{2, 21});
        map.put(15, new int[]{2, 21});
        map.put(16, new int[]{2, 21});
        map.put(18, new int[]{2, 21});
        map.put(21, new int[]{2, 21});
        map.put(22, new int[]{2, 21});
        map.put(23, new int[]{2, 21});
        map.put(24, new int[]{2, 21});
        map.put(25, new int[]{2, 21});
        map.put(26, new int[]{1, 34});
        map.put(27, new int[]{1, 35});
        map.put(28, new int[]{1, 36});
        map.put(38, new int[]{2, 21});
        map.put(39, new int[]{2, 21});
        this.table.add(map);
    }

    private void add64() {
        Map map = new HashMap();
        map.put(5, new int[]{2, 22});
        map.put(14, new int[]{2, 22});
        map.put(15, new int[]{2, 22});
        map.put(16, new int[]{2, 22});
        map.put(18, new int[]{2, 22});
        map.put(21, new int[]{2, 22});
        map.put(22, new int[]{2, 22});
        map.put(23, new int[]{2, 22});
        map.put(24, new int[]{2, 22});
        map.put(25, new int[]{2, 22});
        map.put(26, new int[]{2, 22});
        map.put(27, new int[]{2, 22});
        map.put(28, new int[]{1, 36});
        map.put(38, new int[]{2, 22});
        map.put(39, new int[]{2, 22});
        this.table.add(map);
    }

    private void add65() {
        Map map = new HashMap();
        map.put(5, new int[]{2, 23});
        map.put(14, new int[]{2, 23});
        map.put(15, new int[]{2, 23});
        map.put(16, new int[]{2, 23});
        map.put(18, new int[]{2, 23});
        map.put(21, new int[]{2, 23});
        map.put(22, new int[]{2, 23});
        map.put(23, new int[]{2, 23});
        map.put(24, new int[]{2, 23});
        map.put(25, new int[]{2, 23});
        map.put(26, new int[]{2, 23});
        map.put(27, new int[]{2, 23});
        map.put(28, new int[]{1, 36});
        map.put(38, new int[]{2, 23});
        map.put(39, new int[]{2, 23});
        this.table.add(map);
    }

    private void add66() {
        Map map = new HashMap();
        map.put(5, new int[]{2, 24});
        map.put(14, new int[]{2, 24});
        map.put(15, new int[]{2, 24});
        map.put(16, new int[]{2, 24});
        map.put(18, new int[]{2, 24});
        map.put(21, new int[]{2, 24});
        map.put(22, new int[]{2, 24});
        map.put(23, new int[]{2, 24});
        map.put(24, new int[]{2, 24});
        map.put(25, new int[]{2, 24});
        map.put(26, new int[]{2, 24});
        map.put(27, new int[]{2, 24});
        map.put(28, new int[]{2, 24});
        map.put(38, new int[]{2, 24});
        map.put(39, new int[]{2, 24});
        this.table.add(map);
    }

    private void add67() {
        Map map = new HashMap();
        map.put(5, new int[]{2, 45});
        map.put(14, new int[]{2, 45});
        map.put(15, new int[]{2, 45});
        map.put(16, new int[]{2, 45});
        map.put(18, new int[]{2, 45});
        map.put(21, new int[]{2, 45});
        map.put(22, new int[]{2, 45});
        map.put(23, new int[]{2, 45});
        map.put(24, new int[]{2, 45});
        map.put(25, new int[]{2, 45});
        map.put(26, new int[]{2, 45});
        map.put(27, new int[]{2, 45});
        map.put(28, new int[]{2, 45});
        map.put(38, new int[]{2, 45});
        map.put(39, new int[]{2, 45});
        map.put(41, new int[]{2, 45});
        this.table.add(map);
    }

    private void add68() {
        Map map = new HashMap();
        map.put(5, new int[]{2, 13});
        map.put(14, new int[]{2, 13});
        map.put(15, new int[]{2, 13});
        map.put(16, new int[]{2, 13});
        map.put(18, new int[]{2, 13});
        map.put(21, new int[]{2, 13});
        map.put(22, new int[]{2, 13});
        map.put(23, new int[]{2, 13});
        map.put(24, new int[]{2, 13});
        map.put(25, new int[]{2, 13});
        map.put(26, new int[]{2, 13});
        map.put(27, new int[]{2, 13});
        map.put(28, new int[]{2, 13});
        map.put(38, new int[]{2, 13});
        map.put(39, new int[]{2, 13});
        this.table.add(map);
    }

    private void add69() {
        Map map = new HashMap();
        map.put(5, new int[]{2, 14});
        map.put(14, new int[]{2, 14});
        map.put(15, new int[]{2, 14});
        map.put(16, new int[]{2, 14});
        map.put(18, new int[]{2, 14});
        map.put(21, new int[]{2, 14});
        map.put(22, new int[]{2, 14});
        map.put(23, new int[]{2, 14});
        map.put(24, new int[]{2, 14});
        map.put(25, new int[]{2, 14});
        map.put(26, new int[]{2, 14});
        map.put(27, new int[]{2, 14});
        map.put(28, new int[]{2, 14});
        map.put(38, new int[]{2, 14});
        map.put(39, new int[]{2, 14});
        this.table.add(map);
    }

    private void add70() {
        Map map = new HashMap();
        map.put(2, 18);
        map.put(4, 83);
        map.put(6, 3);
        map.put(7, new int[]{1, 4});
        map.put(8, new int[]{1, 5});
        map.put(9, new int[]{1, 6});
        map.put(10, new int[]{1, 7});
        map.put(11, new int[]{1, 8});
        map.put(12, 9);
        map.put(13, new int[]{1, 10});
        map.put(16, new int[]{1, 14});
        map.put(17, new int[]{1, 11});
        map.put(19, new int[]{1, 12});
        map.put(25, new int[]{1, 13});
        map.put(29, new int[]{1, 15});
        map.put(30, new int[]{1, 16});
        map.put(31, 17);
        map.put(32, new int[]{1, 21});
        map.put(34, new int[]{1, 22});
        map.put(35, new int[]{1, 23});
        map.put(37, new int[]{1, 24});
        map.put(40, new int[]{1, 19});
        map.put(42, new int[]{1, 20});
        map.put(44, new int[]{1, 25});
        this.table.add(map);
    }

    private void add71() {
        Map map = new HashMap();
        map.put(2, 18);
        map.put(4, 84);
        map.put(6, 3);
        map.put(7, new int[]{1, 4});
        map.put(8, new int[]{1, 5});
        map.put(9, new int[]{1, 6});
        map.put(10, new int[]{1, 7});
        map.put(11, new int[]{1, 8});
        map.put(12, 9);
        map.put(13, new int[]{1, 10});
        map.put(16, new int[]{1, 14});
        map.put(17, new int[]{1, 11});
        map.put(19, new int[]{1, 12});
        map.put(25, new int[]{1, 13});
        map.put(29, new int[]{1, 15});
        map.put(30, new int[]{1, 16});
        map.put(31, 17);
        map.put(32, new int[]{1, 21});
        map.put(34, new int[]{1, 22});
        map.put(35, new int[]{1, 23});
        map.put(37, new int[]{1, 24});
        map.put(40, new int[]{1, 19});
        map.put(42, new int[]{1, 20});
        map.put(44, new int[]{1, 25});
        this.table.add(map);
    }

    private void add72() {
        Map map = new HashMap();
        map.put(5, new int[]{2, 28});
        map.put(14, new int[]{2, 28});
        map.put(15, new int[]{2, 28});
        map.put(16, new int[]{2, 28});
        map.put(18, new int[]{2, 28});
        map.put(21, new int[]{2, 28});
        map.put(22, new int[]{2, 28});
        map.put(23, new int[]{2, 28});
        map.put(24, new int[]{2, 28});
        map.put(25, new int[]{2, 28});
        map.put(26, new int[]{2, 28});
        map.put(27, new int[]{2, 28});
        map.put(28, new int[]{2, 28});
        map.put(38, new int[]{2, 28});
        map.put(39, new int[]{2, 28});
        this.table.add(map);
    }

    private void add73() {
        Map map = new HashMap();
        map.put(18, new int[]{1, 85});
        map.put(38, new int[]{1, 69});
        map.put(39, new int[]{1, 70});
        this.table.add(map);
    }

    private void add74() {
        Map map = new HashMap();
        map.put(36, new int[]{1, 86});
        this.table.add(map);
    }

    private void add75() {
        Map map = new HashMap();
        map.put(5, new int[]{2, 47});
        map.put(14, new int[]{2, 47});
        map.put(15, new int[]{2, 47});
        map.put(16, new int[]{2, 47});
        map.put(18, new int[]{2, 47});
        map.put(21, new int[]{2, 47});
        map.put(22, new int[]{2, 47});
        map.put(23, new int[]{2, 47});
        map.put(24, new int[]{2, 47});
        map.put(25, new int[]{2, 47});
        map.put(26, new int[]{2, 47});
        map.put(27, new int[]{2, 47});
        map.put(28, new int[]{2, 47});
        map.put(38, new int[]{2, 47});
        map.put(39, new int[]{2, 47});
        map.put(43, new int[]{2, 47});
        this.table.add(map);
    }

    private void add76() {
        Map map = new HashMap();
        map.put(5, new int[]{2, 34});
        map.put(14, new int[]{2, 34});
        map.put(15, new int[]{2, 34});
        map.put(16, new int[]{2, 34});
        map.put(18, new int[]{2, 34});
        map.put(21, new int[]{2, 34});
        map.put(22, new int[]{2, 34});
        map.put(23, new int[]{2, 34});
        map.put(24, new int[]{2, 34});
        map.put(25, new int[]{2, 34});
        map.put(26, new int[]{2, 34});
        map.put(27, new int[]{2, 34});
        map.put(28, new int[]{2, 34});
        map.put(38, new int[]{2, 34});
        map.put(39, new int[]{2, 34});
        this.table.add(map);
    }

    private void add77() {
        Map map = new HashMap();
        map.put(5, new int[]{2, 36});
        map.put(14, new int[]{2, 36});
        map.put(15, new int[]{2, 36});
        map.put(16, new int[]{2, 36});
        map.put(18, new int[]{2, 36});
        map.put(21, new int[]{2, 36});
        map.put(22, new int[]{2, 36});
        map.put(23, new int[]{2, 36});
        map.put(24, new int[]{2, 36});
        map.put(25, new int[]{2, 36});
        map.put(26, new int[]{2, 36});
        map.put(27, new int[]{2, 36});
        map.put(28, new int[]{2, 36});
        map.put(38, new int[]{2, 36});
        map.put(39, new int[]{2, 36});
        this.table.add(map);
    }

    private void add78() {
        Map map = new HashMap();
        map.put(5, new int[]{2, 37});
        map.put(14, new int[]{2, 37});
        map.put(15, new int[]{2, 37});
        map.put(16, new int[]{2, 37});
        map.put(18, new int[]{2, 37});
        map.put(21, new int[]{2, 37});
        map.put(22, new int[]{2, 37});
        map.put(23, new int[]{2, 37});
        map.put(24, new int[]{2, 37});
        map.put(25, new int[]{2, 37});
        map.put(26, new int[]{2, 37});
        map.put(27, new int[]{2, 37});
        map.put(28, new int[]{2, 37});
        map.put(33, new int[]{1, 87});
        map.put(38, new int[]{2, 37});
        map.put(39, new int[]{2, 37});
        this.table.add(map);
    }

    private void add79() {
        Map map = new HashMap();
        map.put(5, new int[]{2, 40});
        map.put(14, new int[]{2, 40});
        map.put(15, new int[]{2, 40});
        map.put(16, new int[]{2, 40});
        map.put(18, new int[]{2, 40});
        map.put(21, new int[]{2, 40});
        map.put(22, new int[]{2, 40});
        map.put(23, new int[]{2, 40});
        map.put(24, new int[]{2, 40});
        map.put(25, new int[]{2, 40});
        map.put(26, new int[]{2, 40});
        map.put(27, new int[]{2, 40});
        map.put(28, new int[]{2, 40});
        map.put(38, new int[]{2, 40});
        map.put(39, new int[]{2, 40});
        this.table.add(map);
    }

    private void add80() {
        Map map = new HashMap();
        map.put(5, new int[]{2, 49});
        map.put(14, new int[]{2, 49});
        map.put(15, new int[]{2, 49});
        map.put(16, new int[]{2, 49});
        map.put(18, new int[]{2, 49});
        map.put(21, new int[]{2, 49});
        map.put(22, new int[]{2, 49});
        map.put(23, new int[]{2, 49});
        map.put(24, new int[]{2, 49});
        map.put(25, new int[]{2, 49});
        map.put(26, new int[]{2, 49});
        map.put(27, new int[]{2, 49});
        map.put(28, new int[]{2, 49});
        map.put(38, new int[]{2, 49});
        map.put(39, new int[]{2, 49});
        map.put(40, new int[]{2, 49});
        map.put(44, new int[]{2, 49});
        this.table.add(map);
    }

    private void add81() {
        Map map = new HashMap();
        map.put(5, new int[]{2, 15});
        map.put(14, new int[]{2, 15});
        map.put(15, new int[]{2, 15});
        map.put(16, new int[]{1, 29});
        map.put(18, new int[]{2, 15});
        map.put(21, new int[]{2, 15});
        map.put(22, new int[]{2, 15});
        map.put(23, new int[]{2, 15});
        map.put(24, new int[]{2, 15});
        map.put(25, new int[]{1, 33});
        map.put(26, new int[]{1, 34});
        map.put(27, new int[]{1, 35});
        map.put(28, new int[]{1, 36});
        map.put(38, new int[]{2, 15});
        map.put(39, new int[]{2, 15});
        this.table.add(map);
    }

    private void add82() {
        Map map = new HashMap();
        map.put(5, new int[]{2, 17});
        map.put(14, new int[]{2, 17});
        map.put(15, new int[]{2, 17});
        map.put(16, new int[]{1, 29});
        map.put(18, new int[]{2, 17});
        map.put(21, new int[]{2, 17});
        map.put(22, new int[]{2, 17});
        map.put(23, new int[]{2, 17});
        map.put(24, new int[]{2, 17});
        map.put(25, new int[]{1, 33});
        map.put(26, new int[]{1, 34});
        map.put(27, new int[]{1, 35});
        map.put(28, new int[]{1, 36});
        map.put(38, new int[]{2, 17});
        map.put(39, new int[]{2, 17});
        this.table.add(map);
    }

    private void add83() {
        Map map = new HashMap();
        map.put(5, new int[]{2, 16});
        map.put(14, new int[]{2, 16});
        map.put(15, new int[]{2, 16});
        map.put(16, new int[]{1, 29});
        map.put(18, new int[]{2, 16});
        map.put(21, new int[]{2, 16});
        map.put(22, new int[]{2, 16});
        map.put(23, new int[]{2, 16});
        map.put(24, new int[]{2, 16});
        map.put(25, new int[]{1, 33});
        map.put(26, new int[]{1, 34});
        map.put(27, new int[]{1, 35});
        map.put(28, new int[]{1, 36});
        map.put(38, new int[]{2, 16});
        map.put(39, new int[]{2, 16});
        this.table.add(map);
    }

    private void add84() {
        Map map = new HashMap();
        map.put(14, new int[]{1, 27});
        map.put(15, new int[]{1, 28});
        map.put(16, new int[]{1, 29});
        map.put(18, new int[]{2, 42});
        map.put(21, new int[]{2, 42});
        map.put(22, new int[]{1, 30});
        map.put(23, new int[]{1, 31});
        map.put(24, new int[]{1, 32});
        map.put(25, new int[]{1, 33});
        map.put(26, new int[]{1, 34});
        map.put(27, new int[]{1, 35});
        map.put(28, new int[]{1, 36});
        map.put(38, new int[]{2, 42});
        map.put(39, new int[]{2, 42});
        this.table.add(map);
    }

    private void add85() {
        Map map = new HashMap();
        map.put(14, new int[]{1, 27});
        map.put(15, new int[]{1, 28});
        map.put(16, new int[]{1, 29});
        map.put(18, new int[]{2, 43});
        map.put(21, new int[]{2, 43});
        map.put(22, new int[]{1, 30});
        map.put(23, new int[]{1, 31});
        map.put(24, new int[]{1, 32});
        map.put(25, new int[]{1, 33});
        map.put(26, new int[]{1, 34});
        map.put(27, new int[]{1, 35});
        map.put(28, new int[]{1, 36});
        map.put(38, new int[]{2, 43});
        map.put(39, new int[]{2, 43});
        this.table.add(map);
    }

    private void add86() {
        Map map = new HashMap();
        map.put(5, new int[]{2, 29});
        map.put(14, new int[]{2, 29});
        map.put(15, new int[]{2, 29});
        map.put(16, new int[]{2, 29});
        map.put(18, new int[]{2, 29});
        map.put(21, new int[]{2, 29});
        map.put(22, new int[]{2, 29});
        map.put(23, new int[]{2, 29});
        map.put(24, new int[]{2, 29});
        map.put(25, new int[]{2, 29});
        map.put(26, new int[]{2, 29});
        map.put(27, new int[]{2, 29});
        map.put(28, new int[]{2, 29});
        map.put(38, new int[]{2, 29});
        map.put(39, new int[]{2, 29});
        this.table.add(map);
    }

    private void add87() {
        Map map = new HashMap();
        map.put(5, new int[]{2, 50});
        map.put(14, new int[]{2, 50});
        map.put(15, new int[]{2, 50});
        map.put(16, new int[]{2, 50});
        map.put(18, new int[]{2, 50});
        map.put(21, new int[]{2, 50});
        map.put(22, new int[]{2, 50});
        map.put(23, new int[]{2, 50});
        map.put(24, new int[]{2, 50});
        map.put(25, new int[]{2, 50});
        map.put(26, new int[]{2, 50});
        map.put(27, new int[]{2, 50});
        map.put(28, new int[]{2, 50});
        map.put(38, new int[]{2, 50});
        map.put(39, new int[]{2, 50});
        map.put(40, new int[]{2, 50});
        map.put(44, new int[]{2, 50});
        this.table.add(map);
    }

    private void add88() {
        Map map = new HashMap();
        map.put(34, new int[]{1, 88});
        this.table.add(map);
    }

    private void add89() {
        Map map = new HashMap();
        map.put(5, new int[]{2, 38});
        map.put(14, new int[]{2, 38});
        map.put(15, new int[]{2, 38});
        map.put(16, new int[]{2, 38});
        map.put(18, new int[]{2, 38});
        map.put(21, new int[]{2, 38});
        map.put(22, new int[]{2, 38});
        map.put(23, new int[]{2, 38});
        map.put(24, new int[]{2, 38});
        map.put(25, new int[]{2, 38});
        map.put(26, new int[]{2, 38});
        map.put(27, new int[]{2, 38});
        map.put(28, new int[]{2, 38});
        map.put(38, new int[]{2, 38});
        map.put(39, new int[]{2, 38});
        this.table.add(map);
    }
}
